Belgelerim/ceng_491/implementation/doxygen/TraffEdu_Developers_Manual_Reference_ToSource/FileHandler.cpp

Go to the documentation of this file.
00001 /* 
00002 * 
00003 * FileHandler of the system
00004 */
00005 #include "FileHandler.h"
00006 
00007 FileHandler::FileHandler(){
00008         frame = new CMainFrame();
00009 }
00010 
00011 bool FileHandler::loadFile(CArchive& ar)
00012 {
00013         ObjectIDs=0;
00014         int framesLength=0;
00015         vector<int> keyFrames;
00016         osg::ref_ptr<osg::Group> newRoot = new osg::Group;
00017 
00018         osgwind->clearCopiedObjects();
00019         osgwind->clearCutObjects();
00020         osgwind->clearSelectedObjects();
00021 
00022         ph->paintWhiteAll();
00023 
00024 
00025         osgwind->clearFrames();
00026         
00027         int size = osgwind->getConstantRoot()->getNumChildren();        
00028         osg::Node * skyBox= osgwind->getConstantRoot()->getChild(0);
00029         for(int i=0;i<size;i++)
00030         {
00031                 osgwind->getConstantRoot().get()->removeChild(0,1);
00032         }
00033         osgwind->clearObjects();
00034         
00035         osgwind->getConstantRoot()->addChild(skyBox);
00036         
00037         size=osgwind->getTextRoot()->getNumChildren();
00038         for(int i=0;i<size;i++)
00039         {
00040                 osgwind->getTextRoot().get()->removeChild(0,1);
00041         }
00042 
00043         osgwind->getConstantRoot()->addChild(osgwind->getTextRoot().get());
00044 
00045 
00046         theRoadMap=new RoadMap(osgwind->getConstantRoot());
00047         theRoadMap->loadRoadScene();
00048         string xmlFilestr = ar.m_strFileName;
00049         string s2;
00050         string::size_type pos = xmlFilestr.find_last_of("\\");
00051         s2.assign(xmlFilestr, pos+1, xmlFilestr.length());
00052 
00053 
00054         const char *xmlFile = s2.c_str();
00055         EVAL_HR(CoInitialize(NULL));
00056         
00057         const _variant_t v1 = s2.c_str();
00058 
00059     //  MSXML COM smart pointers
00060     //  Use the Dccument2 class to enable schema validation
00061         MSXML2::IXMLDOMDocument2Ptr spDocInput=NULL;
00062         MSXML2::IXMLDOMElementPtr spVisitNode;
00063         MSXML2::IXMLDOMElementPtr spSignNode;
00064         MSXML2::IXMLDOMElementPtr spLightNode;
00065         MSXML2::IXMLDOMElementPtr spVehicleNode;
00066         MSXML2::IXMLDOMElementPtr spFrameNode;
00067     MSXML2::IXMLDOMElementPtr TrafficCaseDocNode;
00068         MSXML2::IXMLDOMElementPtr spKeyFrameNode;
00069     MSXML2::IXMLDOMAttributePtr spSignAttr;
00070         MSXML2::IXMLDOMAttributePtr spLightAttr;
00071         MSXML2::IXMLDOMAttributePtr spFrameAttr;
00072         MSXML2::IXMLDOMAttributePtr spTrafficCaseAttr;
00073     MSXML2::IXMLDOMNodeListPtr spNLChildren;
00074         MSXML2::IXMLDOMAttributePtr     spVehiclesAttr;
00075         MSXML2::IXMLDOMAttributePtr     spVehicleAttr;                                                          
00076         HRESULT hResult = S_OK;
00077 
00078          // Create MSXML DOM object
00079          EVAL_HR(spDocInput.CreateInstance("Msxml2.DOMDocument.4.0"));
00080          
00081 
00082     //  Load the document synchronously
00083 
00084     spDocInput->async =  VARIANT_FALSE; 
00085 
00086     //  Load input document. MSXML default for load is to
00087     //  validate while parsing.
00088     hResult=spDocInput->load(v1);
00089 
00090   
00091     // Check for load, parse, or validation errors
00092     if( hResult != VARIANT_TRUE)
00093     {
00094       return 1;
00095     }
00096 
00097     //  Get document element
00098     TrafficCaseDocNode = spDocInput->documentElement;
00099 
00100         spTrafficCaseAttr = TrafficCaseDocNode->getAttributeNode("FramesNumber");
00101         if(spTrafficCaseAttr!=NULL)
00102         {
00103                 framesLength = stringToInteger(_bstr_t(spTrafficCaseAttr->nodeValue));  //set x , y, z position
00104         }
00105     //  Walk through children of document element
00106     //  and process according to type
00107     spVisitNode = TrafficCaseDocNode->firstChild;
00108         char cNodeType;
00109     while (spVisitNode != NULL)
00110     {
00111       //  Process node depending on type
00112       cNodeType = spVisitNode->nodeType;
00113       switch (cNodeType)
00114       {
00115 
00116         //  Comment Node
00117           case MSXML2::NODE_COMMENT:
00118           break;
00119 
00120         //  Element Node
00121         case MSXML2::NODE_ELEMENT:
00122                 {
00123 
00124           //  Display the value of Attribute1, if present
00125           //  MSXML doesn't support the hasAttribute method,
00126           //  so we'll try to get the Attribute node,
00127           //  then its value.
00128 
00129                  if(_bstr_t(spVisitNode->nodeName)==_bstr_t("Lights"))
00130                   {
00131                          
00132                         spLightNode = spVisitNode->firstChild;
00133                         char cNodeType;
00134 
00135                         while(spLightNode!=NULL)
00136                         {
00137                         
00138                                 cNodeType = spLightNode->nodeType;
00139                                 switch(cNodeType)
00140                                 {
00141                                         //  Comment Node
00142                                         case MSXML2::NODE_COMMENT:
00143                                                 break;
00144                                          //  Element Node
00145                                         case MSXML2::NODE_ELEMENT:
00146                                         {
00147                                                         spLightAttr = spLightNode->getAttributeNode("ObjectID");        
00148                                                         TrafficLight * pLight=new TrafficLight(osgwind);
00149                                                         pLight->setObjectType(LIGHT);           //set object type
00150 
00151                                                         spLightAttr = spLightNode->getAttributeNode("Rotation");
00152                                                         if(spLightAttr!=NULL)
00153                                                         {
00154                                                                 pLight->setRotate(((stringToDouble(_bstr_t(spLightAttr->nodeValue)))),0,0,1);    //set rotate
00155                                                                 
00156                                                         }
00157                                                         spLightAttr = spLightNode->getAttributeNode("Posx");
00158                                                         if(spLightAttr!=NULL)
00159                                                         {
00160                                                                 float x =stringToDouble(_bstr_t(spLightAttr->nodeValue));       //set x , y, z position
00161                                                                 
00162                                                                 spLightAttr = spLightNode->getAttributeNode("Posy");
00163                                                                 float y =stringToDouble(_bstr_t(spLightAttr->nodeValue));
00164                                                                 
00165                                                                 spLightAttr = spLightNode->getAttributeNode("Posz");
00166                                                                 float z =stringToDouble(_bstr_t(spLightAttr->nodeValue));
00167                                                                 
00168                                                                 pLight->setPosition(x,y,z);     
00169                                                         }
00170                                                         
00171                                                         spLightAttr = spLightNode->getAttributeNode("BeforeCreated");
00172                                                         if(spLightAttr!=NULL)
00173                                                         {
00174                                                                 pLight->setIsBeforeCreated(0);//stringToInteger(_bstr_t(spLightAttr->nodeValue)));      //set object id
00175                                                                 
00176                                                         }
00177                                                         
00178                                                         spLightAttr = spLightNode->getAttributeNode("LightColor");
00179                                                         if(spLightAttr!=NULL)
00180                                                         {
00181                                                                 pLight->setColor(KIRMIZI);//stringToInteger(_bstr_t(spLightAttr->nodeValue)));  //set object id
00182                                                         
00183                                                         }
00184                                                         spFrameNode = spLightNode->firstChild;
00185                                                         
00186                                                         while(spFrameNode!=NULL)
00187                                                         {
00188                                                                 cNodeType = spFrameNode->nodeType;
00189                                                                 switch(cNodeType)
00190                                                                 {
00191                                                                         case MSXML2::NODE_COMMENT:
00192                                                                                 break;
00193                                                                         case MSXML2::NODE_ELEMENT:
00194                                                                         {
00195                                                                                 int frameId;
00196                                                                                 int color;
00197                                                                                 spFrameAttr = spFrameNode->getAttributeNode("KeyFrameID");
00198                                                                                 if(spFrameAttr!=NULL)
00199                                                                                 {
00200                                                                                         frameId = stringToInteger(_bstr_t(spFrameAttr->nodeValue));
00201                                                                                 
00202                                                                                 }
00203                                                                                 
00204                                                                                 spFrameAttr = spFrameNode->getAttributeNode("LightColor");
00205                                                                                 if(spFrameAttr!=NULL)
00206                                                                                 {
00207                                                                                         color=stringToInteger(_bstr_t(spFrameAttr->nodeValue)); 
00208                                                                                 
00209                                                                                 }
00210                                                                                 pLight->setFrameColor(frameId,color);
00211                                                                                 break;
00212                                                                         }
00213                                                                 }
00214                                                                 spFrameNode = spFrameNode->nextSibling;
00215                                                         }
00216                                                         pLight->setScale(0.5,0.5,0.5);
00217                                                         pLight->getObjectGroup()->setUserData(pLight);  
00218                                                         osgwind->addObject(pLight);
00219                                                         osgwind->doAddGeode(pLight);
00220                                                         break;
00221                                         }                                       
00222                                 }               
00223                                 spLightNode = spLightNode->nextSibling;
00224                                         }
00225                                 
00226                         }
00227                   else if(_bstr_t(spVisitNode->nodeName)==_bstr_t("KeyFrames")){
00228                                 spKeyFrameNode = spVisitNode->firstChild;
00229                                 char cNodeType;
00230                         int ebru=1;
00231                         while(spKeyFrameNode!=NULL)
00232                         {
00233                                 cNodeType = spKeyFrameNode->nodeType;
00234                                 switch(cNodeType)
00235                                 {
00236                                         //  Comment Node
00237                                         case MSXML2::NODE_COMMENT:
00238                                                 break;
00239                                          //  Element Node
00240                                         case MSXML2::NODE_ELEMENT:
00241                                         {
00242                                                 spFrameAttr = spKeyFrameNode->getAttributeNode("KeyFrameID");
00243                                                 if(spFrameAttr!=NULL)
00244                                                 {
00245                                                         
00246                                                         keyFrames.push_back(stringToInteger(_bstr_t(spFrameAttr->nodeValue)));
00247                                                         Frame* frame = new Frame(stringToInteger(_bstr_t(spFrameAttr->nodeValue)));
00248                                                         osgwind->getFrames().push_back(frame);
00249                                                         if(ebru == 1)
00250                                                         {
00251                                                                 int id=frame->getFrameId();
00252                                                                 osgwind->setCurrentFrameId(id);//-1);
00253                                                                 osgwind->setClickedFrameId(id);//-1);
00254                                                                 osgwind->setOnDisplayFrameId(id);//-1);
00255                                                                 ebru++;
00256                                                         }
00257                                                 }
00258                                         }
00259                                 }
00260                                 spKeyFrameNode = spKeyFrameNode->nextSibling;
00261                   }
00262                   }
00263 
00264                  else if(_bstr_t(spVisitNode->nodeName)==_bstr_t("Vehicles"))
00265                   {
00266                         spVehicleNode = spVisitNode->firstChild;
00267                         char cNodeType;
00268                         int cagla;
00269                         int can = 1;
00270                         int type=0;
00271                         while(spVehicleNode!=NULL)
00272                         {
00273                                 spVehicleAttr = spVehicleNode->getAttributeNode("VehicleType");
00274                                 if(spVehicleAttr!=NULL)
00275                                 {
00276                                         type = stringToInteger(_bstr_t(spVehicleAttr->nodeValue));
00277                                 
00278                                 }
00279                                 
00280                                 Vehicle * pVehicle = new Vehicle("models/carModels/dodgemax/butun.osg",0.025);
00281                                 if(type==1)
00282                                 {
00283                                         pVehicle->setModelPath("models/carModels/semimax/butun.osg");
00284                                 }
00285 
00286                                 pVehicle->getObjectGroup()->setUserData(pVehicle);      
00287                                 osgwind->addObject(pVehicle); 
00288 
00289                                 int patSirasi=0;
00290                                 cNodeType = spVehicleNode->nodeType;
00291                                 switch(cNodeType)
00292                                 {
00293                                         //  Comment Node
00294                                         case MSXML2::NODE_COMMENT:
00295                                                 break;
00296                                          //  Element Node
00297                                         case MSXML2::NODE_ELEMENT:
00298                                         {
00299                                                         spFrameNode = spVehicleNode->firstChild;
00300                                                         
00301                                                         while(spFrameNode!=NULL)
00302                                                         {
00303                                                                 cagla = 1;
00304                                                                 float x,y,z, rotation;
00305                                                                 osg::Vec3f position;
00306                                                                 cNodeType = spFrameNode->nodeType;
00307                                                                 switch(cNodeType)
00308                                                                 {
00309                                                                         case MSXML2::NODE_COMMENT:
00310                                                                                 break;
00311                                                                         case MSXML2::NODE_ELEMENT:
00312                                                                         {
00313                                                                                 spFrameAttr = spFrameNode->getAttributeNode("KeyFrameID");
00314                                                                                 if(spFrameAttr!=NULL)
00315                                                                                 {
00316                                                                                         int frameId = stringToInteger(_bstr_t(spFrameAttr->nodeValue));
00317                                                                                         pVehicle->getObjectPATvector().at(patSirasi)->frameID = frameId;//set x , y, z position
00318                                                                                 }
00319                                                                                 
00320                                                                                 spFrameAttr = spFrameNode->getAttributeNode("Rotation");
00321                                                                                 if(spFrameAttr!=NULL)
00322                                                                                 {
00323                                                                                         rotation=stringToDouble(_bstr_t(spFrameAttr->nodeValue));       //set x , y, z position
00324                                                                                         pVehicle->getObjectPATvector().at(patSirasi)->objectPAT->setAttitude(osg::Quat(osg::inDegrees(rotation),osg::Vec3(0,0,1)));
00325                                                                                 }
00326 
00327                                                                                 spFrameAttr = spFrameNode->getAttributeNode("Posx");
00328                                                                                 if(spFrameAttr!=NULL)
00329                                                                                 {
00330                                                                                         x=stringToDouble(_bstr_t(spFrameAttr->nodeValue));      //set x , y, z position
00331                                                                                         position.x()=x;
00332                                                                                 }
00333 
00334                                                                                 spFrameAttr = spFrameNode->getAttributeNode("Posy");
00335                                                                                 if(spFrameAttr!=NULL)
00336                                                                                 {
00337                                                                                         y=stringToDouble(_bstr_t(spFrameAttr->nodeValue));      //set x , y, z position
00338                                                                                         position.y()=y;
00339                                                                                 }
00340                                                                                 spFrameAttr = spFrameNode->getAttributeNode("Posz");
00341                                                                                 if(spFrameAttr!=NULL)
00342                                                                                 {
00343                                                                                         z=stringToDouble(_bstr_t(spFrameAttr->nodeValue));      //set x , y, z position
00344                                                                                         position.z()=z;
00345                                                                                 }
00346                                                                                 
00347                                                                                 
00348                                                                                 pVehicle->getObjectPATvector().at(patSirasi)->objectPAT->setPosition(position);
00349                                                                         }
00350                                                                         patSirasi++;
00351                                                                 }
00352                                                                 spFrameNode = spFrameNode->nextSibling;
00353                                                                 if(cagla == 1)
00354                                                                 {
00355                                                                         osgwind->doAddGeode(pVehicle);
00356                                                                         cagla++;
00357                                                                 }
00358                                                                 
00359                                                         }
00360                                         }
00361                                 }
00362                                 
00363                                 spVehicleNode = spVehicleNode->nextSibling;
00364                         }
00365                   }
00366                   
00367             else if(_bstr_t(spVisitNode->nodeName)==_bstr_t("Signs"))
00368                   {
00369                         
00370                         spSignNode = spVisitNode->firstChild;
00371                         char cNodeType;
00372 
00373                         while(spSignNode!=NULL)
00374                         {
00375                                 cNodeType = spSignNode->nodeType;
00376                                 switch(cNodeType)
00377                                 {
00378                                         //  Comment Node
00379                                         case MSXML2::NODE_COMMENT:
00380                                                 break;
00381                                          //  Element Node
00382                                         case MSXML2::NODE_ELEMENT:
00383                                         {
00384                                                         spSignAttr = spSignNode->getAttributeNode("ObjectID");  
00385                                                         TrafficSign * pSign=new TrafficSign();
00386                                                         pSign->setObjectType(SIGN);             //set object type
00387                                                         spSignAttr = spSignNode->getAttributeNode("Rotation");
00388                                                         if(spSignAttr!=NULL)
00389                                                         {
00390                                                                 pSign->setRotate(((stringToDouble(_bstr_t(spSignAttr->nodeValue)))),0,0,1);      //set rotate
00391                                                         }
00392                                                         spSignAttr = spSignNode->getAttributeNode("Posx");
00393                                                         if(spSignAttr!=NULL)
00394                                                         {
00395                                                                 float x =stringToDouble(_bstr_t(spSignAttr->nodeValue));        //set x , y, z position
00396                                                                 spSignAttr = spSignNode->getAttributeNode("Posy");
00397                                                                 float y =stringToDouble(_bstr_t(spSignAttr->nodeValue));
00398                                                                 spSignAttr = spSignNode->getAttributeNode("Posz");
00399                                                                 float z =stringToDouble(_bstr_t(spSignAttr->nodeValue));
00400                                                                 pSign->setPosition(x,y,z);      
00401                                                         }
00402                                                         
00403                                                         spSignAttr = spSignNode->getAttributeNode("BeforeCreated");
00404                                                         if(spSignAttr!=NULL)
00405                                                         {
00406                                                                 pSign->setIsBeforeCreated(0);
00407                                                         }
00408                                                         
00409                                                         pSign->setScale(0.5,0.5,0.5);
00410                                                         pSign->getObjectGroup()->setUserData(pSign);    
00411                                                         osgwind->addObject(pSign);
00412                                                         osgwind->doAddGeode(pSign);
00413                                                         break;
00414                                                         
00415                                         }
00416                                 
00417                                 }
00418                                 spSignNode = spSignNode->nextSibling;
00419                         }
00420                   
00421                   }
00422                 
00423                 }
00424           }
00425           spVisitNode=spVisitNode->nextSibling; 
00426         }
00427 
00428         for(int i=0; i<osgwind->getObjects().size();i++)
00429         {
00430                 
00431                 if(osgwind->getObjects().at(i)->getObjectType()==VEHICLE)
00432                 {
00433                         int totalPAT=osgwind->sizeOfFrames();
00434                 }
00435         }
00436         for(int i=0;i<framesLength;i++)
00437         {
00438                 osgwind->setCurrentFrameId(keyFrames.at(i));
00439                 osgwind->loadFrame(keyFrames.at(i));            
00440         }
00441 
00442   CoUninitialize();
00443  pos = s2.find_first_of(".");
00444         
00445         if (pos != string::npos) 
00446         {
00447                 string sub = s2.substr(0,pos);
00448                 sub.append(".osg");
00449                 loadRoadMap(sub);
00450         }
00451         int id=osgwind->getFrames()[0]->getFrameId();
00452         osgwind->setCurrentFrameId(id);
00453         osgwind->setClickedFrameId(id);
00454         osgwind->setOnDisplayFrameId(id);
00455 return true;
00456 }
00457 
00458 
00459 bool FileHandler::saveFile(CArchive& ar){
00460 
00461         bool lightFlag=false;
00462         bool signFlag=false;
00463         bool vehicleFlag=false;
00464         ofstream xmlTestFile("savexml.txt");
00465         string xmlFilestr = ar.m_strFileName;
00466         string s2;
00467         string::size_type pos = xmlFilestr.find_last_of("\\");
00468         
00469         s2.assign(xmlFilestr, pos+1, xmlFilestr.length());
00470 
00471         const char *xmlFile = s2.c_str();
00472         
00473         EVAL_HR(CoInitialize(NULL));
00474          IXMLDOMDocument2Ptr pXMLDoc = NULL;
00475          
00476          // Create MSXML DOM object
00477          EVAL_HR(pXMLDoc.CreateInstance("Msxml2.DOMDocument.4.0"));
00478          MSXML2::IXMLDOMProcessingInstructionPtr pPI = NULL;
00479 
00480          pPI = pXMLDoc->createProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");
00481 
00482         _variant_t vNullVal;
00483         vNullVal.vt = VT_NULL;
00484         pXMLDoc->insertBefore(pPI, vNullVal);
00485         MSXML2::IXMLDOMNodePtr pRootNode= NULL;
00486         _variant_t varNodeType((short)MSXML2::NODE_ELEMENT);
00487 
00488         pRootNode= pXMLDoc->createNode(varNodeType,"TrafficCase", "");
00489         pXMLDoc->appendChild(pRootNode);
00490         
00491         MSXML2::IXMLDOMAttributePtr pTrafficCaseAttr = NULL;
00492         pTrafficCaseAttr = pXMLDoc->createAttribute("FramesNumber");
00493         pTrafficCaseAttr->nodeTypedValue = osgwind->getFrames().size();
00494         pRootNode->attributes->setNamedItem(pTrafficCaseAttr);
00495 
00496         MSXML2::IXMLDOMNodePtr pKeyFramesNode= NULL;
00497         pKeyFramesNode = pRootNode->appendChild(pXMLDoc->createElement("KeyFrames"));
00498         for(int i=0;i<osgwind->getFrames().size();i++){
00499                 MSXML2::IXMLDOMNodePtr pKeyFrameNode= NULL;
00500                 pKeyFrameNode = pKeyFramesNode->appendChild(pXMLDoc->createElement("KeyFrame"));
00501 
00502                 MSXML2::IXMLDOMAttributePtr pFrameTypeAttr = NULL;
00503                 pFrameTypeAttr = pXMLDoc->createAttribute("KeyFrameID");
00504                 pFrameTypeAttr->nodeTypedValue = osgwind->getFrames().at(i)->getFrameId();
00505                 pKeyFrameNode->attributes->setNamedItem(pFrameTypeAttr);
00506 
00507         }
00508 
00509 
00510         MSXML2::IXMLDOMNodePtr pRoadNode= NULL;
00511         pRoadNode = pRootNode->appendChild(pXMLDoc->createElement("Road"));
00512 
00513         MSXML2::IXMLDOMNodePtr pLightsNode= NULL;
00514         pLightsNode = pRootNode->appendChild(pXMLDoc->createElement("Lights"));
00515 
00516         MSXML2::IXMLDOMNodePtr pSignsNode= NULL;
00517         pSignsNode = pRootNode->appendChild(pXMLDoc->createElement("Signs"));
00518         
00519         MSXML2::IXMLDOMNodePtr pVehiclesNode= NULL;
00520         pVehiclesNode = pRootNode->appendChild(pXMLDoc->createElement("Vehicles"));
00521 
00522         for(int i=0;i<osgwind->getObjects().size();i++)
00523         {
00524                 if(osgwind->getObjects().at(i)->getCondition()=='a')
00525                 {
00526                         if(osgwind->getObjects().at(i)->getObjectType()==LIGHT)
00527                         {
00528                                 TrafficLight * pLight =dynamic_cast<TrafficLight *>(osgwind->getObjects().at(i));
00529                                 MSXML2::IXMLDOMNodePtr pLightNode= NULL;
00530                                 pLightNode = pLightsNode->appendChild(pXMLDoc->createElement("Light"));
00531                                 
00532                                 MSXML2::IXMLDOMAttributePtr pLightObjectIDAttr = NULL;
00533                                 pLightObjectIDAttr = pXMLDoc->createAttribute("ObjectID");
00534                                 pLightObjectIDAttr->nodeTypedValue = pLight->getObjectId();
00535                                 pLightNode->attributes->setNamedItem(pLightObjectIDAttr);
00536                                 
00537                                 
00538                                 MSXML2::IXMLDOMAttributePtr pLightTypeAttr = NULL;
00539                                 pLightTypeAttr = pXMLDoc->createAttribute("LightColor");
00540                                 pLightTypeAttr->nodeTypedValue = pLight->getColor();
00541                                 pLightNode->attributes->setNamedItem(pLightTypeAttr);
00542 
00543 
00544                                 MSXML2::IXMLDOMAttributePtr pLightRotationAttr = NULL;
00545                                 pLightRotationAttr = pXMLDoc->createAttribute("Rotation");
00546                                 pLightRotationAttr->nodeTypedValue = pLight->getm_drotz();
00547                                 pLightNode->attributes->setNamedItem(pLightRotationAttr);
00548 
00549                                 osg::Vec3d pos = pLight->getPosition();
00550                                 MSXML2::IXMLDOMAttributePtr pLightPositionxAttr = NULL;
00551                                 pLightPositionxAttr = pXMLDoc->createAttribute("Posx");
00552                                 pLightPositionxAttr->nodeTypedValue = pos.x();
00553                                 pLightNode->attributes->setNamedItem(pLightPositionxAttr);
00554 
00555                                 MSXML2::IXMLDOMAttributePtr pLightPositionyAttr = NULL;
00556                                 pLightPositionyAttr = pXMLDoc->createAttribute("Posy");
00557                                 pLightPositionyAttr->nodeTypedValue = pos.y();
00558                                 pLightNode->attributes->setNamedItem(pLightPositionyAttr);
00559 
00560                                 MSXML2::IXMLDOMAttributePtr pLightPositionzAttr = NULL;
00561                                 pLightPositionzAttr = pXMLDoc->createAttribute("Posz");
00562                                 pLightPositionzAttr->nodeTypedValue = pos.z();
00563                                 pLightNode->attributes->setNamedItem(pLightPositionzAttr);
00564 
00565                                 MSXML2::IXMLDOMAttributePtr pLightBeforeCreatedAttr = NULL;
00566                                 pLightBeforeCreatedAttr = pXMLDoc->createAttribute("BeforeCreated");
00567                                 pLightBeforeCreatedAttr->nodeTypedValue = pLight->getIsBeforeCreated();
00568                                 pLightNode->attributes->setNamedItem(pLightBeforeCreatedAttr);
00569 
00570                                 for(int j=0;j<osgwind->getFrames().size();j++)
00571                                 {
00572                                         TrafficLightColor color = pLight->getFrameColor(osgwind->getFrames()[j]->getFrameId());
00573                                         
00574                                         
00575                                         MSXML2::IXMLDOMNodePtr pFrameNode= NULL;
00576                                         pFrameNode = pLightNode->appendChild(pXMLDoc->createElement("Frame"));
00577 
00578                                         MSXML2::IXMLDOMAttributePtr pFrameIDAttr = NULL;
00579                                         pFrameIDAttr = pXMLDoc->createAttribute("KeyFrameID");
00580                                         pFrameIDAttr->nodeTypedValue = osgwind->getFrames()[j]->getFrameId();
00581                                         pFrameNode->attributes->setNamedItem(pFrameIDAttr);
00582                                 
00583 
00584                                         MSXML2::IXMLDOMAttributePtr FrameColorAttr = NULL;
00585                                         FrameColorAttr = pXMLDoc->createAttribute("LightColor");
00586                                         FrameColorAttr->nodeTypedValue = color;
00587                                         pFrameNode->attributes->setNamedItem(FrameColorAttr);
00588                                 }
00589                         }
00590                         else if(osgwind->getObjects().at(i)->getObjectType()==SIGN )
00591                         {
00592                                 TrafficSign * pSign =dynamic_cast<TrafficSign *>(osgwind->getObjects().at(i));
00593                                 MSXML2::IXMLDOMNodePtr pSignNode= NULL;
00594                                 pSignNode = pSignsNode->appendChild(pXMLDoc->createElement("Sign"));
00595 
00596                                 MSXML2::IXMLDOMAttributePtr pSignObjectIDAttr = NULL;
00597                                 pSignObjectIDAttr = pXMLDoc->createAttribute("ObjectID");
00598                                 pSignObjectIDAttr->nodeTypedValue = pSign->getObjectId();
00599                                 pSignNode->attributes->setNamedItem(pSignObjectIDAttr);
00600                                 
00601                                 
00602                                 MSXML2::IXMLDOMAttributePtr pSignTypeAttr = NULL;
00603                                 pSignTypeAttr = pXMLDoc->createAttribute("SignType");
00604                                 pSignTypeAttr->nodeTypedValue = pSign->getTrafficSignType();
00605                                 pSignNode->attributes->setNamedItem(pSignTypeAttr);
00606 
00607 
00608                                 MSXML2::IXMLDOMAttributePtr pSignRotationAttr = NULL;
00609                                 pSignRotationAttr = pXMLDoc->createAttribute("Rotation");
00610                                 pSignRotationAttr->nodeTypedValue = pSign->getm_drotz();
00611                                 pSignNode->attributes->setNamedItem(pSignRotationAttr);
00612 
00613                                 osg::Vec3d pos = pSign->getPosition();
00614                                 MSXML2::IXMLDOMAttributePtr pSignPositionxAttr = NULL;
00615                                 pSignPositionxAttr = pXMLDoc->createAttribute("Posx");
00616                                 pSignPositionxAttr->nodeTypedValue = pos.x();
00617                                 pSignNode->attributes->setNamedItem(pSignPositionxAttr);
00618 
00619                                 MSXML2::IXMLDOMAttributePtr pSignPositionyAttr = NULL;
00620                                 pSignPositionyAttr = pXMLDoc->createAttribute("Posy");
00621                                 pSignPositionyAttr->nodeTypedValue = pos.y();
00622                                 pSignNode->attributes->setNamedItem(pSignPositionyAttr);
00623 
00624                                 MSXML2::IXMLDOMAttributePtr pSignPositionzAttr = NULL;
00625                                 pSignPositionzAttr = pXMLDoc->createAttribute("Posz");
00626                                 pSignPositionzAttr->nodeTypedValue = pos.z();
00627                                 pSignNode->attributes->setNamedItem(pSignPositionzAttr);
00628 
00629                                 MSXML2::IXMLDOMAttributePtr pSignBeforeCreatedAttr = NULL;
00630                                 pSignBeforeCreatedAttr = pXMLDoc->createAttribute("BeforeCreated");
00631                                 pSignBeforeCreatedAttr->nodeTypedValue = pSign->getIsBeforeCreated();
00632                                 pSignNode->attributes->setNamedItem(pSignBeforeCreatedAttr);
00633                         }
00634 
00635                         else if(osgwind->getObjects().at(i)->getObjectType()==VEHICLE )
00636                         {
00637                                 Vehicle * pVehicle =dynamic_cast<Vehicle *>(osgwind->getObjects().at(i));
00638                                 MSXML2::IXMLDOMNodePtr pVehicleNode= NULL;
00639                                 pVehicleNode = pVehiclesNode->appendChild(pXMLDoc->createElement("Vehicle"));
00640                                 
00641                                 MSXML2::IXMLDOMAttributePtr pVehicleTypeAttr = NULL;
00642                                         pVehicleTypeAttr = pXMLDoc->createAttribute("VehicleType");
00643 
00644                                         if(pVehicle->getModelPath() == "models/carModels/dodgemax/butun.osg"){
00645                                                 pVehicleTypeAttr->nodeTypedValue = 0;
00646                                         }
00647                                         else {
00648                                                 pVehicleTypeAttr->nodeTypedValue = 1;
00649                                         }                                       
00650                                         pVehicleNode->attributes->setNamedItem(pVehicleTypeAttr);
00651                                 for(int j=0;j<pVehicle->getObjectPATvector().size();j++)
00652                                 {
00653                                         osg::Quat angle;
00654                                         osg::Vec3f position;
00655                                         vehiclePAT* pVehiclePAT = pVehicle->getObjectPATvector().at(j);
00656                                         
00657                                         
00658                                         pVehiclePAT->objectPAT->getAttitude().getRotate(angle[0],angle[1],angle[2],angle[3]);
00659                                         double rotation=RAD2DEG(angle[0]);
00660                                         
00661                                         position =pVehiclePAT->objectPAT->getPosition();
00662                                         float x=position[0];
00663                                         float y=position[1];
00664                                         float z=position[2];
00665 
00666                                         MSXML2::IXMLDOMNodePtr pFrameNode= NULL;
00667                                         pFrameNode = pVehicleNode->appendChild(pXMLDoc->createElement("Frame"));
00668 
00669                                         MSXML2::IXMLDOMAttributePtr pFrameIDAttr = NULL;
00670                                         pFrameIDAttr = pXMLDoc->createAttribute("KeyFrameID");
00671                                         pFrameIDAttr->nodeTypedValue = pVehiclePAT->frameID;
00672                                         pFrameNode->attributes->setNamedItem(pFrameIDAttr);
00673                                 
00674 
00675                                         MSXML2::IXMLDOMAttributePtr FrameRotationAttr = NULL;
00676                                         FrameRotationAttr = pXMLDoc->createAttribute("Rotation");
00677                                         FrameRotationAttr->nodeTypedValue = rotation;
00678                                         pFrameNode->attributes->setNamedItem(FrameRotationAttr);
00679                                         
00680                                         MSXML2::IXMLDOMAttributePtr pFramePositionxAttr = NULL;
00681                                         pFramePositionxAttr = pXMLDoc->createAttribute("Posx");
00682                                         pFramePositionxAttr->nodeTypedValue = x;
00683                                         pFrameNode->attributes->setNamedItem(pFramePositionxAttr);
00684 
00685                                         MSXML2::IXMLDOMAttributePtr pFramePositionyAttr = NULL;
00686                                         pFramePositionyAttr = pXMLDoc->createAttribute("Posy");
00687                                         pFramePositionyAttr->nodeTypedValue = y;
00688                                         pFrameNode->attributes->setNamedItem(pFramePositionyAttr);
00689 
00690                                         MSXML2::IXMLDOMAttributePtr pFramePositionzAttr = NULL;
00691                                         pFramePositionzAttr = pXMLDoc->createAttribute("Posz");
00692                                         pFramePositionzAttr->nodeTypedValue = z;
00693                                         pFrameNode->attributes->setNamedItem(pFramePositionzAttr);
00694                                 }
00695 
00696                         }
00697                 }
00698         }
00699         ar.WriteString(pXMLDoc->Getxml());
00700         ar.Flush();
00701         ar.Close();
00702         CoUninitialize();
00703         return true;
00704 }
00705 
00706 
00707 void FileHandler::saveRoadMap(string sub)
00708 {
00709         osgDB::writeNodeFile(*(theRoadMap->returnRoadNode().get()) , sub);
00710 }
00711 void FileHandler::loadRoadMap(string sub)
00712 {
00713         osg::ref_ptr<osg::Node> roadscene = osgDB::readNodeFile(sub,NULL);
00714         theRoadMap->addRoadNode(roadscene);
00715 }

Generated on Sun May 28 18:54:09 2006 for TraffEdu by  doxygen 1.4.6-NO